{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "1、针对分类问题，激活函数为Relu，观察准确率差异",
   "id": "b4273766969de575"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:02.043707Z",
     "start_time": "2025-03-07T11:13:00.006468Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import tqdm.auto as tqdm\n",
    "import sklearn\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n"
   ],
   "id": "bfc387a130b7dcc2",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "显示系统硬件信息",
   "id": "45ac5a3e893227aa"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:02.062206Z",
     "start_time": "2025-03-07T11:13:02.044711Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(sys.version_info)\n",
    "for moudle in np, pd, sklearn, mpl, torch:\n",
    "    print(moudle.__name__, moudle.__version__)\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n"
   ],
   "id": "51e9347961ed87bb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "matplotlib 3.9.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 准备数据和数据预处理",
   "id": "43904d6b561b4635"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:02.998477Z",
     "start_time": "2025-03-07T11:13:02.062206Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets  # 加载数据集\n",
    "from torchvision import transforms  # 将图片转换为tensor\n",
    "\n",
    "# 定义数据集的变换\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将图片转换为tensor\n",
    "    # transforms.Normalize((0.1307,), (0.3081,))  # 归一化\n",
    "])\n",
    "\n",
    "# fashion MNIST 数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分"
   ],
   "id": "3f6581b9e9eccb7",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.002196Z",
     "start_time": "2025-03-07T11:13:02.999480Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 打印数据集信息\n",
    "print(train_ds)\n",
    "# 打印测试集的信息\n",
    "print('-' * 50)\n",
    "print(test_ds)"
   ],
   "id": "43ef446a782874e8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset FashionMNIST\n",
      "    Number of datapoints: 60000\n",
      "    Root location: data\n",
      "    Split: Train\n",
      "    StandardTransform\n",
      "Transform: Compose(\n",
      "               ToTensor()\n",
      "           )\n",
      "--------------------------------------------------\n",
      "Dataset FashionMNIST\n",
      "    Number of datapoints: 10000\n",
      "    Root location: data\n",
      "    Split: Test\n",
      "    StandardTransform\n",
      "Transform: Compose(\n",
      "               ToTensor()\n",
      "           )\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.018617Z",
     "start_time": "2025-03-07T11:13:03.002196Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 将数据转存到DataLoaders中,只有训练集需要shuffle。\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
    "# 把测试数据也转存到DataLoaders中，变成一个batch\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)\n",
    "# 打印DataLoaders的类型\n",
    "print(type(train_loader))\n",
    "# 查看在dataloader中取出的batch的大小\n",
    "print('-' * 50)\n",
    "for data in train_loader:\n",
    "    print(type(data))\n",
    "    print(type(data[0]))\n",
    "    print(data[0].shape)\n",
    "    print(type(data[1]))\n",
    "    print(data[1].shape)\n",
    "    break\n",
    "print('-' * 50)\n",
    "for data, label in train_loader:\n",
    "    print(data.shape)\n",
    "    print(label.shape)\n",
    "    break"
   ],
   "id": "28b7aa8bc6717aae",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torch.utils.data.dataloader.DataLoader'>\n",
      "--------------------------------------------------\n",
      "<class 'list'>\n",
      "<class 'torch.Tensor'>\n",
      "torch.Size([32, 1, 28, 28])\n",
      "<class 'torch.Tensor'>\n",
      "torch.Size([32])\n",
      "--------------------------------------------------\n",
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义模型",
   "id": "f29b95d11abd31be"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.023439Z",
     "start_time": "2025-03-07T11:13:03.018617Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        # 调用父类的初始化方法\n",
    "        super().__init__()\n",
    "        # 定义网络结构\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 300),  # 输入层到隐藏层\n",
    "            nn.SELU(),  # 激活函数\n",
    "            nn.Linear(300, 100),  # 隐藏层到输出层\n",
    "            nn.SELU(),  # 激活函数\n",
    "            nn.Linear(100, 10),  # 输出层\n",
    "        )\n",
    "\n",
    "    # 定义前向传播过程\n",
    "    def forward(self, x):\n",
    "        # 定义前向传播过程\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = NeuralNetwork()"
   ],
   "id": "adae75e7c6f88492",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "4b52a1afb420335d"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "pytorch的训练需要自行实现：\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义tensorboard\n",
    "4. 定义earlystopping\n",
    "5. 定义checkpoint\n",
    "6. 定义训练循环，步数\n",
    "7. 训练"
   ],
   "id": "996beb88c8590b3c"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "定义损失器和优化器",
   "id": "8657cd69cdaff902"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.056813Z",
     "start_time": "2025-03-07T11:13:03.023439Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# 定义损失函数,nn.CrossEntropyLoss()是多分类用的损失函数,叫做交叉熵\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "# 定义优化器,SGD是随机梯度下降法,momentum是动量法,lr是学习率\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)"
   ],
   "id": "42c794a66bba835f",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "定义earlystopping",
   "id": "d3c31fb7587c4a09"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.060954Z",
     "start_time": "2025-03-07T11:13:03.056813Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStoppingCallback:\n",
    "    # c\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "        早停（Early Stopping）回调类，用于在训练过程中监控模型性能，防止过拟合。\n",
    "        当验证集上的性能在连续 `patience` 个 epoch 内没有改善时，停止训练。\n",
    "        Args:\n",
    "            patience (int, optional): \n",
    "                在训练停止前，可以容忍验证集性能没有改善的最大 epoch 数。\n",
    "                例如，如果 `patience=5`，则在验证集性能连续 5 个 epoch 没有改善时，训练将停止。\n",
    "                默认值为 5。\n",
    "                \n",
    "            min_delta (float, optional): \n",
    "                监控指标的最小变化量，用于判断是否算作性能改善。\n",
    "                如果验证集性能的变化量小于 `min_delta`，则认为性能没有改善。\n",
    "                例如，如果 `min_delta=0.01`，则验证集性能的变化必须大于 0.01 才算作改善。\n",
    "                默认值为 0.01。\n",
    "        \"\"\"\n",
    "        self.patience = patience  # 容忍度\n",
    "        self.min_delta = min_delta  # 最小变化\n",
    "        self.best_metric = -1  # 初始化最佳指标为-1\n",
    "        self.counter = 0  # 计数器，记录连续多少个epoch没有提升\n",
    "\n",
    "    # 定义__call__方法，在训练过程中调用.回调函数的入口，会在训练过程中调用\n",
    "    def __call__(self, metric):\n",
    "        \"\"\"\n",
    "        回调函数，在每个 epoch 结束后调用，检查是否需要停止训练。\n",
    "        Args:\n",
    "            current_metric (float): 当前 epoch 的验证集性能指标。\n",
    "        Returns:\n",
    "            bool: 如果需要停止训练，返回 True；否则返回 False。\n",
    "        \"\"\"\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果当前指标大于或等于最佳指标+最小变化\n",
    "            self.best_metric = metric  # 更新最佳指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加1\n",
    "\n",
    "    @property  # 定义@property装饰器，使得实例可以像属性一样访问patience和min_delta\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience  # 如果计数器大于或等于容忍度，则返回True，表示停止训练"
   ],
   "id": "5b0d0239b96c8544",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义评估函数",
   "id": "18407eb1797c1979"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.068752Z",
     "start_time": "2025-03-07T11:13:03.060954Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluating(model, dataloader, loss_func):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 正向传播\n",
    "        logits = model(datas)\n",
    "\n",
    "        loss = loss_func(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f946e5e5c8bf8fb7",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "3c7be1e3fd244e21"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:13:03.075115Z",
     "start_time": "2025-03-07T11:13:03.069756Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# \n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_func,\n",
    "        optimizer,\n",
    "        early_stopping_callback=None,\n",
    "        sval_step=500):\n",
    "    \"\"\"\n",
    "    训练函数，用于训练模型并监控验证集性能。\n",
    "    Args:\n",
    "        model: 要训练的模型。\n",
    "        train_loader: 训练数据加载器，提供训练数据和标签。\n",
    "        val_loader: 验证数据加载器，提供验证数据和标签。\n",
    "        epoch: 总的训练轮数。\n",
    "        loss_func: 损失函数，用于计算模型的损失。\n",
    "        optimizer: 优化器，用于更新模型的参数。\n",
    "        tensorboard_callback: TensorBoard 回调函数，用于记录训练过程中的指标。\n",
    "        save_checkpoint_callback: 保存检查点的回调函数，用于保存模型。\n",
    "        early_stopping_callback: 早停回调函数，用于防止过拟合。\n",
    "        sval_step (int, optional): 每隔多少步进行一次验证。默认为500。\n",
    "    \"\"\"\n",
    "    record_dict = {\n",
    "        \"train\": [],  # 记录训练过程中的指标\n",
    "        \"val\": []  # 记录验证过程中的指标\n",
    "    }\n",
    "    # 全局步数\n",
    "    global_step = 0\n",
    "    # 切换到训练模式\n",
    "    model.train()\n",
    "    # 使用 tqdm 显示进度条，总步数为 sval_step\n",
    "    with tqdm.tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # 遍历训练数据加载器，获取数据和标签\n",
    "            for datas, labels in train_loader:\n",
    "                # 把数据转存到device\n",
    "                datas = datas.to(device)\n",
    "                # 把标签转存到device\n",
    "                labels = labels.to(device)\n",
    "                # # 优化器梯度清零，避免梯度累积\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算，获取输出\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_func(logits, labels)\n",
    "                #  损失反向传播，计算梯度\n",
    "                loss.backward()\n",
    "                # # 优化器更新模型参数\n",
    "                optimizer.step()\n",
    "                # 获取预测类别\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                # 将损失从 GPU 移到 CPU，并转换为 Python 标量\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "                # 切换回训练模式\n",
    "                model.train()\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % sval_step == 0:\n",
    "                    # 验证模式\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_func)\n",
    "                    record_dict[\"val\"].append({  # 记录验证过程中的指标\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    # 切换回训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 3、early_stopping_callback\n",
    "                    if early_stopping_callback is not None:\n",
    "                        early_stopping_callback(val_acc)\n",
    "                        if early_stopping_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                # 全局步数加1\n",
    "                global_step += 1\n",
    "                # 进度条更新\n",
    "                pbar.update(1)\n",
    "                # 进度条显示\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "21a1d7f40c15d95c",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:14:28.129220Z",
     "start_time": "2025-03-07T11:13:03.075115Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStoppingCallback(patience=10)\n",
    "# early_stop_callback = None\n",
    "model = model.to(device)\n",
    "# 训练\n",
    "record = training(model,\n",
    "                  train_loader,\n",
    "                  val_loader,\n",
    "                  epoch,\n",
    "                  loss_func,\n",
    "                  optimizer,\n",
    "                  early_stop_callback,\n",
    "                  sval_step=1000\n",
    "                  )\n"
   ],
   "id": "523a6f503740116",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/18750 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "9c195f55f2c4499caa499dc75879a917"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 画图观察损失和准确率变化",
   "id": "f7615abbb4f647ca"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:14:28.220864Z",
     "start_time": "2025-03-07T11:14:28.129220Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    # print(train_df.head())\n",
    "    # print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)  #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))  #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data = range(0, train_df.index[-1], 5000)  #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))  #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "4228f1cf03030315",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:14:28.859488Z",
     "start_time": "2025-03-07T11:14:28.220864Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True, map_location=\"cuda:0\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_func)\n",
    "print(f\"loss:{loss:.4f}\\naccuracy:{acc:.4f}\")"
   ],
   "id": "e135039b3c0cbf3f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:0.3982\n",
      "accuracy:0.8551\n"
     ]
    }
   ],
   "execution_count": 13
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
